/*
Copyright 2021,xiyinli
*/
#include "iic_moni.h"
#include "delay.h"
#include "usart.h"
#include "stdio.h"
#include "math.h"

/************************引脚定义区***************************************
* @note：
* @IIC1  PB0->SCL;PB1->SDA;
* @IIC2  PB2->SCL;PB3->SDA;
* @IIC3  PB4->SCL;PB5->SDA;
* @IIC4  PB6->SCL;PB7->SDA;
* @date 2020/01/18 by xiyinli in hust;
  @date 2021/09/30 by xiyinli in hust;
*************************************************************************/
#define RCC_IIC_SCL    RCC_AHB1Periph_GPIOB  //端口时钟
#define IIC_SCL_PORT   GPIOB                 //端口
#define IIC1_SCL       GPIO_Pin_0            //引脚
#define IIC2_SCL 			 GPIO_Pin_2
#define IIC3_SCL			 GPIO_Pin_4
#define IIC4_SCL	 		 GPIO_Pin_6
#define RCC_IIC_SDA    RCC_AHB1Periph_GPIOB  //端口时钟
#define IIC_SDA_PORT   GPIOB                 //端口
#define IIC1_SDA       GPIO_Pin_1            //引脚
#define IIC2_SDA   		 GPIO_Pin_3
#define IIC3_SDA			 GPIO_Pin_5
#define IIC4_SDA       GPIO_Pin_7

/**************************************************************************/
#define IIC1_SCL_OFFSET (uint8_t)(log(IIC1_SCL)/log(2))
#define IIC1_SDA_OFFSET (uint8_t)(log(IIC1_SDA)/log(2))
#define IIC2_SCL_OFFSET (uint8_t)(log(IIC2_SCL)/log(2))
#define IIC2_SDA_OFFSET (uint8_t)(log(IIC2_SDA)/log(2))
#define IIC3_SCL_OFFSET (uint8_t)(log(IIC3_SCL)/log(2))
#define IIC3_SDA_OFFSET (uint8_t)(log(IIC3_SDA)/log(2))
#define IIC4_SCL_OFFSET (uint8_t)(log(IIC4_SCL)/log(2))
#define IIC4_SDA_OFFSET (uint8_t)(log(IIC4_SDA)/log(2))

#define SDA1_IN()  {IIC_SDA_PORT->MODER&=~(3<<(IIC1_SDA_OFFSET*2));IIC_SDA_PORT->MODER|=0<<IIC1_SDA_OFFSET*2;}
#define SDA1_OUT() {IIC_SDA_PORT->MODER&=~(3<<(IIC1_SDA_OFFSET*2));IIC_SDA_PORT->MODER|=1<<IIC1_SDA_OFFSET*2;}
#define SDA2_IN()  {IIC_SDA_PORT->MODER&=~(3<<(IIC2_SDA_OFFSET*2));IIC_SDA_PORT->MODER|=0<<IIC2_SDA_OFFSET*2;}
#define SDA2_OUT() {IIC_SDA_PORT->MODER&=~(3<<(IIC2_SDA_OFFSET*2));IIC_SDA_PORT->MODER|=1<<IIC2_SDA_OFFSET*2;}
#define SDA3_IN()  {IIC_SDA_PORT->MODER&=~(3<<(IIC3_SDA_OFFSET*2));IIC_SDA_PORT->MODER|=0<<IIC3_SDA_OFFSET*2;}
#define SDA3_OUT() {IIC_SDA_PORT->MODER&=~(3<<(IIC3_SDA_OFFSET*2));IIC_SDA_PORT->MODER|=1<<IIC3_SDA_OFFSET*2;}
#define SDA4_IN()  {IIC_SDA_PORT->MODER&=~(3<<(IIC4_SDA_OFFSET*2));IIC_SDA_PORT->MODER|=0<<IIC4_SDA_OFFSET*2;}
#define SDA4_OUT() {IIC_SDA_PORT->MODER&=~(3<<(IIC4_SDA_OFFSET*2));IIC_SDA_PORT->MODER|=1<<IIC4_SDA_OFFSET*2;}


#define IIC1_SCL_H    IIC_SCL_PORT->BSRRL |= IIC1_SCL //SCL1
#define IIC1_SCL_L    IIC_SCL_PORT->BSRRH |= IIC1_SCL //SCL1
#define IIC1_SDA_H    IIC_SDA_PORT->BSRRL |= IIC1_SDA //SDA1 
#define IIC1_SDA_L    IIC_SDA_PORT->BSRRH |= IIC1_SDA //SDA1 
#define IIC2_SCL_H    IIC_SCL_PORT->BSRRL |= IIC2_SCL //SCL2
#define IIC2_SCL_L    IIC_SCL_PORT->BSRRH |= IIC2_SCL //SCL2
#define IIC2_SDA_H    IIC_SDA_PORT->BSRRL |= IIC2_SDA //SDA2 
#define IIC2_SDA_L    IIC_SDA_PORT->BSRRH |= IIC2_SDA //SDA2 
#define IIC3_SCL_H    IIC_SCL_PORT->BSRRL |= IIC3_SCL //SCL3
#define IIC3_SCL_L    IIC_SCL_PORT->BSRRH |= IIC3_SCL //SCL3
#define IIC3_SDA_H    IIC_SDA_PORT->BSRRL |= IIC3_SDA //SDA3 
#define IIC3_SDA_L    IIC_SDA_PORT->BSRRH |= IIC3_SDA //SDA3 
#define IIC4_SCL_H    IIC_SCL_PORT->BSRRL |= IIC4_SCL //SCL4
#define IIC4_SCL_L    IIC_SCL_PORT->BSRRH |= IIC4_SCL //SCL4
#define IIC4_SDA_H    IIC_SDA_PORT->BSRRL |= IIC4_SDA //SDA4 
#define IIC4_SDA_L    IIC_SDA_PORT->BSRRH |= IIC4_SDA //SDA4 


#define READ_SDA1     (IIC_SDA_PORT->IDR&IIC1_SDA) ? 1 : 0 //输入SDA 
#define READ_SDA2    	(IIC_SDA_PORT->IDR&IIC2_SDA) ? 1 : 0 //输入SDA 
#define READ_SDA3     (IIC_SDA_PORT->IDR&IIC3_SDA) ? 1 : 0 //输入SDA 
#define READ_SDA4     (IIC_SDA_PORT->IDR&IIC4_SDA) ? 1 : 0 //输入SDA 

/******************************************************************************
*函  数：void IIC_Init(void)
*功　能：IIC初始化
*参  数：无
*返回值：无
*备  注：无
*******************************************************************************/
void IIC_Init(void)
{
    GPIO_InitTypeDef  GPIO_InitStructure;

    RCC_AHB1PeriphClockCmd(RCC_IIC_SDA, ENABLE);
    RCC_AHB1PeriphClockCmd(RCC_IIC_SCL, ENABLE);

    GPIO_InitStructure.GPIO_Pin = IIC1_SCL|IIC2_SCL|IIC3_SCL|IIC4_SCL;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT; //选择模式
    GPIO_InitStructure.GPIO_OType = GPIO_OType_OD; //开漏输出类型
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(IIC_SCL_PORT, &GPIO_InitStructure);

    GPIO_InitStructure.GPIO_Pin = IIC1_SDA|IIC2_SDA|IIC3_SDA|IIC4_SDA;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT; //选择模式
    GPIO_InitStructure.GPIO_OType = GPIO_OType_OD; //开漏输出类型
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP; //仅仅对配置成输入时有效
    GPIO_Init(IIC_SDA_PORT, &GPIO_InitStructure);

    IIC1_SCL_H;
    IIC1_SDA_H;
    IIC2_SCL_H;
    IIC2_SDA_H;
    IIC3_SCL_H;
    IIC3_SDA_H;
    IIC4_SCL_H;
    IIC4_SDA_H;
}
/******************************************************************************
*函  数：void IIC_Start(void)
*功　能：产生IIC起始信号
*******************************************************************************/
void IIC1_Start(void)
{
    SDA1_OUT(); //sda线输出
    IIC1_SDA_H;
    IIC1_SCL_H;
    delay_us(4);
    IIC1_SDA_L; //START:when CLK is high,DATA change form high to low
    delay_us(4);
    IIC1_SCL_L; //钳住I2C总线，准备发送或接收数据
}

void IIC2_Start(void)
{
    SDA2_OUT();
    IIC2_SDA_H;
    IIC2_SCL_H;
    delay_us(4);
    IIC2_SDA_L;
    delay_us(4);
    IIC2_SCL_L;
}

void IIC3_Start(void)
{
    SDA3_OUT();
    IIC3_SDA_H;
    IIC3_SCL_H;
    delay_us(4);
    IIC3_SDA_L;
    delay_us(4);
    IIC3_SCL_L;
}
void IIC4_Start(void)
{
    SDA4_OUT();
    IIC4_SDA_H;
    IIC4_SCL_H;
    delay_us(4);
    IIC4_SDA_L;
    delay_us(4);
    IIC4_SCL_L;
}

/******************************************************************************
*函  数：void IIC_Stop(void)
*功　能：产生IIC停止信号
*******************************************************************************/
void IIC1_Stop(void)
{
    SDA1_OUT(); //sda线输出
    IIC1_SCL_L;
    IIC1_SDA_L; //STOP:when CLK is high DATA change form low to high
    delay_us(4);
    IIC1_SCL_H;
    IIC1_SDA_H; //发送I2C总线结束信号
    delay_us(4);
}

void IIC2_Stop(void)
{
    SDA2_OUT();
    IIC2_SCL_L;
    IIC2_SDA_L;
    delay_us(4);
    IIC2_SCL_H;
    IIC2_SDA_H;
    delay_us(4);
}

void IIC3_Stop(void)
{
    SDA3_OUT();
    IIC3_SCL_L;
    IIC3_SDA_L;
    delay_us(4);
    IIC3_SCL_H;
    IIC3_SDA_H;
    delay_us(4);
}
void IIC4_Stop(void)
{
    SDA4_OUT();
    IIC4_SCL_L;
    IIC4_SDA_L;
    delay_us(4);
    IIC4_SCL_H;
    IIC4_SDA_H;
    delay_us(4);
}
/******************************************************************************
*函  数: uint8_t IIC_WaitAck(void)
*功　能: 等待应答信号到来 （有效应答：从机第9个 SCL=0 时 SDA 被从机拉低,
                            并且 SCL = 1时 SDA依然为低）
*返回值：1，接收应答失败
         0，接收应答成功
*备  注：从机给主机的应答
*******************************************************************************/
uint8_t IIC1_WaitAck(void)
{
    uint8_t ucErrTime=0;
    SDA1_IN(); //SDA设置为输入  （从机给一个低电平做为应答）
    IIC1_SDA_H;
    delay_us(1);
    IIC1_SCL_H;
    delay_us(1);
    while(READ_SDA1)
    {
        ucErrTime++;
        if(ucErrTime>250)
        {
            IIC1_Stop();
            return 1;
        }
    }
    IIC1_SCL_L; //时钟输出0
    return 0;
}

uint8_t IIC2_WaitAck(void)
{
    uint8_t ucErrTime=0;
    SDA2_IN(); //SDA设置为输入  （从机给一个低电平做为应答）
    IIC2_SDA_H;
    delay_us(1);
    IIC2_SCL_H;
    delay_us(1);
    while(READ_SDA2)
    {
        ucErrTime++;
        if(ucErrTime>250)
        {
            IIC2_Stop();
            return 1;
        }
    }
    IIC2_SCL_L; //时钟输出0
    return 0;
}

uint8_t IIC3_WaitAck(void)
{
    uint8_t ucErrTime=0;
    SDA3_IN(); //SDA设置为输入  （从机给一个低电平做为应答）
    IIC3_SDA_H;
    delay_us(1);
    IIC3_SCL_H;
    delay_us(1);
    while(READ_SDA3)
    {
        ucErrTime++;
        if(ucErrTime>250)
        {
            IIC3_Stop();
            return 1;
        }
    }
    IIC3_SCL_L; //时钟输出0
    return 0;
}

uint8_t IIC4_WaitAck(void)
{
    uint8_t ucErrTime=0;
    SDA4_IN(); //SDA设置为输入  （从机给一个低电平做为应答）
    IIC4_SDA_H;
    delay_us(1);
    IIC4_SCL_H;
    delay_us(1);
    while(READ_SDA4)
    {
        ucErrTime++;
        if(ucErrTime>250)
        {
            IIC4_Stop();
            return 1;
        }
    }
    IIC4_SCL_L; //时钟输出0
    return 0;
}
/******************************************************************************
*函  数: void IIC_Ack(void)
*功　能: 产生ACK应答 （主机接收完一个字节数据后，主机产生的ACK通知从机一个
                       字节数据已正确接收）
*参  数：无
*返回值：无
*备  注：主机给从机的应答
*******************************************************************************/

void IIC1_Ack(void)
{
    IIC1_SCL_L;
    SDA1_OUT();
    IIC1_SDA_L;
    delay_us(1);
    IIC1_SCL_H;
    delay_us(2);
    IIC1_SCL_L;
}

void IIC2_Ack(void)
{
    IIC2_SCL_L;
    SDA2_OUT();
    IIC2_SDA_L;
    delay_us(1);
    IIC2_SCL_H;
    delay_us(2);
    IIC2_SCL_L;
}

void IIC3_Ack(void)
{
    IIC3_SCL_L;
    SDA3_OUT();
    IIC3_SDA_L;
    delay_us(1);
    IIC3_SCL_H;
    delay_us(2);
    IIC3_SCL_L;
}

void IIC4_Ack(void)
{
    IIC4_SCL_L;
    SDA4_OUT();
    IIC4_SDA_L;
    delay_us(1);
    IIC4_SCL_H;
    delay_us(2);
    IIC4_SCL_L;
}


/******************************************************************************
*函  数: void IIC_NAck(void)
*功　能: 产生NACK应答 （主机接收完最后一个字节数据后，主机产生的NACK通知从机
                        发送结束，释放SDA,以便主机产生停止信号）
*参  数：无
*返回值：无
*备  注：主机给从机的应答
*******************************************************************************/
void IIC1_NAck(void)
{
    IIC1_SCL_L;
    SDA1_OUT();
    IIC1_SDA_H;
    delay_us(1);
    IIC1_SCL_H;
    delay_us(1);
    IIC1_SCL_L;
}

void IIC2_NAck(void)
{
    IIC2_SCL_L;
    SDA2_OUT();
    IIC2_SDA_H;
    delay_us(1);
    IIC2_SCL_H;
    delay_us(1);
    IIC2_SCL_L;
}

void IIC3_NAck(void)
{
    IIC3_SCL_L;
    SDA3_OUT();
    IIC3_SDA_H;
    delay_us(1);
    IIC3_SCL_H;
    delay_us(1);
    IIC3_SCL_L;
}

void IIC4_NAck(void)
{
    IIC4_SCL_L;
    SDA4_OUT();
    IIC4_SDA_H;
    delay_us(1);
    IIC4_SCL_H;
    delay_us(1);
    IIC4_SCL_L;
}

/******************************************************************************
*函  数：void IIC_SendByte(uint8_t txd)
*功  能：IIC发送一个字节
*参  数：data 要写的数据
*返回值：无
*备  注：主机往从机发
*******************************************************************************/
void IIC_SendByte(uint8_t IIC_BUS,uint8_t data)
{
    if(IIC_BUS == IIC_BUS1)
    {
        uint8_t t;
        SDA1_OUT();
        IIC1_SCL_L; //拉低时钟开始数据传输
        for(t=0; t<8; t++)
        {
            if((data&0x80)>>7)
                IIC1_SDA_H;
            else
                IIC1_SDA_L;
            data<<=1;
            delay_us(1);
            IIC1_SCL_H;
            delay_us(1);
            IIC1_SCL_L;
            delay_us(1);
        }
    }
    else if(IIC_BUS == IIC_BUS2)
    {
        uint8_t t;
        SDA2_OUT();
        IIC2_SCL_L; //拉低时钟开始数据传输
        for(t=0; t<8; t++)
        {
            if((data&0x80)>>7)
                IIC2_SDA_H;
            else
                IIC2_SDA_L;
            data<<=1;
            delay_us(1);
            IIC2_SCL_H;
            delay_us(1);
            IIC2_SCL_L;
            delay_us(1);
        }
    }
    else if(IIC_BUS == IIC_BUS3)
    {
        uint8_t t;
        SDA3_OUT();
        IIC3_SCL_L; //拉低时钟开始数据传输
        for(t=0; t<8; t++)
        {
            if((data&0x80)>>7)
                IIC3_SDA_H;
            else
                IIC3_SDA_L;
            data<<=1;
            delay_us(1);
            IIC3_SCL_H;
            delay_us(1);
            IIC3_SCL_L;
            delay_us(1);
        }
    }
    else if(IIC_BUS == IIC_BUS4)
    {
        uint8_t t;
        SDA4_OUT();
        IIC4_SCL_L; //拉低时钟开始数据传输
        for(t=0; t<8; t++)
        {
            if((data&0x80)>>7)
                IIC4_SDA_H;
            else
                IIC4_SDA_L;
            data<<=1;
            delay_us(1);
            IIC4_SCL_H;
            delay_us(1);
            IIC4_SCL_L;
            delay_us(1);
        }
    }
}

/******************************************************************************
*函  数：uint8_t IIC_ReadByte(uint8_t ack)
*功  能：IIC读取一个字节
*参  数：ack=1 时，主机数据还没接收完 ack=0 时主机数据已全部接收完成
*返回值：无
*备  注：从机往主机发
*******************************************************************************/
uint8_t IIC_ReadByte(uint8_t IIC_BUS,uint8_t ack)
{
    if(IIC_BUS == IIC_BUS1)
    {
        uint8_t i,receive=0;
        SDA1_IN(); //SDA设置为输入模式 等待接收从机返回数据
        for(i=0; i<8; i++ )
        {
            IIC1_SCL_L;
            delay_us(1);
            IIC1_SCL_H;
            receive<<=1;
            if(READ_SDA1)receive++; //从机发送的电平
            delay_us(1);
        }
        if(ack)
            IIC1_Ack(); //发送ACK
        else
            IIC1_NAck(); //发送nACK
        return receive;
    }
    else if(IIC_BUS == IIC_BUS2)
    {
        uint8_t i,receive=0;
        SDA2_IN(); //SDA设置为输入模式 等待接收从机返回数据
        for(i=0; i<8; i++ )
        {
            IIC2_SCL_L;
            delay_us(1);
            IIC2_SCL_H;
            receive<<=1;
            if(READ_SDA2)receive++; //从机发送的电平
            delay_us(1);
        }
        if(ack)
            IIC2_Ack(); //发送ACK
        else
            IIC2_NAck(); //发送nACK
        return receive;
    }
    else if(IIC_BUS == IIC_BUS3)
    {
        uint8_t i,receive=0;
        SDA3_IN(); //SDA设置为输入模式 等待接收从机返回数据
        for(i=0; i<8; i++ )
        {
            IIC3_SCL_L;
            delay_us(1);
            IIC3_SCL_H;
            receive<<=1;
            if(READ_SDA3)receive++; //从机发送的电平
            delay_us(1);
        }
        if(ack)
            IIC3_Ack(); //发送ACK
        else
            IIC3_NAck(); //发送nACK
        return receive;
    }
    else if(IIC_BUS == IIC_BUS4)
    {
        uint8_t i,receive=0;
        SDA4_IN(); //SDA设置为输入模式 等待接收从机返回数据
        for(i=0; i<8; i++ )
        {
            IIC4_SCL_L;
            delay_us(1);
            IIC4_SCL_H;
            receive<<=1;
            if(READ_SDA4)receive++; //从机发送的电平
            delay_us(1);
        }
        if(ack)
            IIC4_Ack(); //发送ACK
        else
            IIC4_NAck(); //发送nACK
        return receive;
    }
    return 0xff;//防止警告
}

/******************************************************************************
*函  数：uint8_t IIC_ReadByteFromSlave(uint8_t I2C_Addr,uint8_t addr)
*功　能：读取指定设备 指定寄存器的一个值
*参  数：I2C_Addr  目标设备地址
		     reg	     寄存器地址
         *buf      读取数据要存储的地址
*返回值：返回 1失败 0成功
*备  注：无
*******************************************************************************/
uint8_t IIC_ReadByteFromSlave(uint8_t IIC_BUS,uint8_t I2C_Addr,uint8_t reg,uint8_t *buf)
{
    if(IIC_BUS == IIC_BUS1)
    {
        IIC1_Start();
        IIC_SendByte(IIC_BUS1,I2C_Addr<<1|0);	 //发送从机地址
        if(IIC1_WaitAck()) //如果从机未应答则数据发送失败
        {
            IIC1_Stop();
            return 1;
        }
        IIC_SendByte(IIC_BUS1,reg); //发送寄存器地址
        IIC1_WaitAck();
        IIC1_Start();
        IIC_SendByte(IIC_BUS1,I2C_Addr<<1|1); //进入接收模式
        IIC1_WaitAck();
        *buf=IIC_ReadByte(IIC_BUS1,0);
        IIC1_Stop(); //产生一个停止条件
        return 0;
    }
    else if(IIC_BUS == IIC_BUS2)
    {
        IIC2_Start();
        IIC_SendByte(IIC_BUS2,I2C_Addr<<1|0);	 //发送从机地址
        if(IIC2_WaitAck()) //如果从机未应答则数据发送失败
        {
            IIC2_Stop();
            return 1;
        }
        IIC_SendByte(IIC_BUS2,reg); //发送寄存器地址
        IIC2_WaitAck();
        IIC2_Start();
        IIC_SendByte(IIC_BUS2,I2C_Addr<<1|1); //进入接收模式
        IIC2_WaitAck();
        *buf=IIC_ReadByte(IIC_BUS2,0);
        IIC2_Stop(); //产生一个停止条件
        return 0;
    }
    else if(IIC_BUS == IIC_BUS3)
    {
        IIC3_Start();
        IIC_SendByte(IIC_BUS3,I2C_Addr<<1|0);	 //发送从机地址
        if(IIC3_WaitAck()) //如果从机未应答则数据发送失败
        {
            IIC3_Stop();
            return 1;
        }
        IIC_SendByte(IIC_BUS3,reg); //发送寄存器地址
        IIC3_WaitAck();
        IIC3_Start();
        IIC_SendByte(IIC_BUS3,I2C_Addr<<1|1); //进入接收模式
        IIC3_WaitAck();
        *buf=IIC_ReadByte(IIC_BUS3,0);
        IIC3_Stop(); //产生一个停止条件
        return 0;
    }
    else if(IIC_BUS == IIC_BUS4)
    {
        IIC4_Start();
        IIC_SendByte(IIC_BUS4,I2C_Addr<<1|0);	 //发送从机地址
        if(IIC4_WaitAck()) //如果从机未应答则数据发送失败
        {
            IIC4_Stop();
            return 1;
        }
        IIC_SendByte(IIC_BUS4,reg); //发送寄存器地址
        IIC4_WaitAck();
        IIC4_Start();
        IIC_SendByte(IIC_BUS4,I2C_Addr<<1|1); //进入接收模式
        IIC4_WaitAck();
        *buf=IIC_ReadByte(IIC_BUS4,0);
        IIC4_Stop(); //产生一个停止条件
        return 0;
    }
    return 0xff;
}

/******************************************************************************
*函  数：uint8_t IIC_WriteByteFromSlave(uint8_t I2C_Addr,uint8_t addr，uint8_t buf))
*功　能：写入指定设备 指定寄存器的一个值
*参  数：I2C_Addr  目标设备地址
		     reg	     寄存器地址
         buf       要写入的数据
*返回值：1 失败 0成功
*备  注：无
*******************************************************************************/
uint8_t IIC_WriteByteToSlave(uint8_t IIC_BUS,uint8_t I2C_Addr,uint8_t reg,uint8_t data)
{
    if(IIC_BUS == IIC_BUS1)
    {
        IIC1_Start();
        IIC_SendByte(IIC_BUS1,I2C_Addr<<1|0); //发送从机地址
        if(IIC1_WaitAck())
        {
            IIC1_Stop();
            return 1; //从机地址写入失败
        }
        IIC_SendByte(IIC_BUS1,reg); //发送寄存器地址
        IIC1_WaitAck();
        IIC_SendByte(IIC_BUS1,data);
        if(IIC1_WaitAck())
        {
            IIC1_Stop();
            return 1; //数据写入失败
        }
        IIC1_Stop(); //产生一个停止条件
        return 0;
    }
    else if(IIC_BUS == IIC_BUS2)
    {
        IIC2_Start();
        IIC_SendByte(IIC_BUS2,I2C_Addr<<1|0); //发送从机地址
        if(IIC2_WaitAck())
        {
            IIC2_Stop();
            return 1; //从机地址写入失败
        }
        IIC_SendByte(IIC_BUS2,reg); //发送寄存器地址
        IIC2_WaitAck();
        IIC_SendByte(IIC_BUS2,data);
        if(IIC2_WaitAck())
        {
            IIC2_Stop();
            return 1; //数据写入失败
        }
        IIC2_Stop(); //产生一个停止条件
        return 0;
    }
    else if(IIC_BUS == IIC_BUS3)
    {
        IIC3_Start();
        IIC_SendByte(IIC_BUS3,I2C_Addr<<1|0); //发送从机地址
        if(IIC3_WaitAck())
        {
            IIC3_Stop();
            return 1; //从机地址写入失败
        }
        IIC_SendByte(IIC_BUS3,reg); //发送寄存器地址
        IIC3_WaitAck();
        IIC_SendByte(IIC_BUS3,data);
        if(IIC3_WaitAck())
        {
            IIC3_Stop();
            return 1; //数据写入失败
        }
        IIC3_Stop(); //产生一个停止条件
        return 0;
    }
    else if(IIC_BUS == IIC_BUS4)
    {
        IIC4_Start();
        IIC_SendByte(IIC_BUS4,I2C_Addr<<1|0); //发送从机地址
        if(IIC4_WaitAck())
        {
            IIC4_Stop();
            return 1; //从机地址写入失败
        }
        IIC_SendByte(IIC_BUS4,reg); //发送寄存器地址
        IIC4_WaitAck();
        IIC_SendByte(IIC_BUS4,data);
        if(IIC4_WaitAck())
        {
            IIC4_Stop();
            return 1; //数据写入失败
        }
        IIC4_Stop(); //产生一个停止条件
        return 0;
    }
    return 0xff;
}

/******************************************************************************
*函  数：uint8_t IICreadBytes(uint8_t dev, uint8_t reg, uint8_t length, uint8_t *data)
*功　能：读取指定设备 指定寄存器的 length个值
*参  数：dev     目标设备地址
		     reg	   寄存器地址
         length  要读的字节数
		     *data   读出的数据将要存放的指针
*返回值：1成功 0失败
*备  注：无
*******************************************************************************/
uint8_t IIC_ReadMultByteFromSlave(uint8_t IIC_BUS,uint8_t I2C_Addr, uint8_t reg, uint8_t length, uint8_t *data)
{
    if(IIC_BUS == IIC_BUS1)
    {
        uint8_t count = 0;
        uint8_t temp;
        IIC1_Start();
        IIC_SendByte(IIC_BUS1,I2C_Addr<<1|0); //发送从机地址
        if(IIC1_WaitAck())
        {
            IIC1_Stop();
            return 1; //从机地址写入失败
        }
        IIC_SendByte(IIC_BUS1,reg); //发送寄存器地址
        IIC1_WaitAck();
        IIC1_Start();
        IIC_SendByte(IIC_BUS1,I2C_Addr<<1|1); //进入接收模式
        IIC1_WaitAck();
        for(count=0; count<length; count++)
        {
            if(count!=(length-1))
                temp = IIC_ReadByte(IIC_BUS1,1); //带ACK的读数据
            else
                temp = IIC_ReadByte(IIC_BUS1,0); //最后一个字节NACK

            data[count] = temp;
        }
        IIC1_Stop(); //产生一个停止条件
        return 0;
    }
    else if(IIC_BUS == IIC_BUS2)
    {
        uint8_t count = 0;
        uint8_t temp;
        IIC2_Start();
        IIC_SendByte(IIC_BUS2,I2C_Addr<<1|0); //发送从机地址
        if(IIC2_WaitAck())
        {
            IIC2_Stop();
            return 1; //从机地址写入失败
        }
        IIC_SendByte(IIC_BUS2,reg); //发送寄存器地址
        IIC2_WaitAck();
        IIC2_Start();
        IIC_SendByte(IIC_BUS2,I2C_Addr<<1|1); //进入接收模式
        IIC2_WaitAck();
        for(count=0; count<length; count++)
        {
            if(count!=(length-1))
                temp = IIC_ReadByte(IIC_BUS2,1); //带ACK的读数据
            else
                temp = IIC_ReadByte(IIC_BUS2,0); //最后一个字节NACK

            data[count] = temp;
        }
        IIC2_Stop(); //产生一个停止条件
        return 0;
    }
    else if(IIC_BUS == IIC_BUS3)
    {
        uint8_t count = 0;
        uint8_t temp;
        IIC3_Start();
        IIC_SendByte(IIC_BUS3,I2C_Addr<<1|0); //发送从机地址
        if(IIC3_WaitAck())
        {
            IIC3_Stop();
            return 1; //从机地址写入失败
        }
        IIC_SendByte(IIC_BUS3,reg); //发送寄存器地址
        IIC3_WaitAck();
        IIC3_Start();
        IIC_SendByte(IIC_BUS3,I2C_Addr<<1|1); //进入接收模式
        IIC3_WaitAck();
        for(count=0; count<length; count++)
        {
            if(count!=(length-1))
                temp = IIC_ReadByte(IIC_BUS3,1); //带ACK的读数据
            else
                temp = IIC_ReadByte(IIC_BUS3,0); //最后一个字节NACK

            data[count] = temp;
        }
        IIC3_Stop(); //产生一个停止条件
        return 0;
    }
    else if(IIC_BUS == IIC_BUS4)
    {
        uint8_t count = 0;
        uint8_t temp;
        IIC4_Start();
        IIC_SendByte(IIC_BUS4,I2C_Addr<<1|0); //发送从机地址
        if(IIC4_WaitAck())
        {
            IIC4_Stop();
            return 1; //从机地址写入失败
        }
        IIC_SendByte(IIC_BUS4,reg); //发送寄存器地址
        IIC4_WaitAck();
        IIC4_Start();
        IIC_SendByte(IIC_BUS4,I2C_Addr<<1|1); //进入接收模式
        IIC4_WaitAck();
        for(count=0; count<length; count++)
        {
            if(count!=(length-1))
                temp = IIC_ReadByte(IIC_BUS4,1); //带ACK的读数据
            else
                temp = IIC_ReadByte(IIC_BUS4,0); //最后一个字节NACK

            data[count] = temp;
        }
        IIC4_Stop(); //产生一个停止条件
        return 0;
    }
    return 0xff;
}

/******************************************************************************
*函  数：uint8_t IICwriteBytes(uint8_t dev, uint8_t reg, uint8_t length, uint8_t* data)
*功　能：将多个字节写入指定设备 指定寄存器
*参  数：dev     目标设备地址
		     reg	   寄存器地址
         length  要写的字节数
		     *data   要写入的数据将要存放的指针
*返回值：1成功 0失败
*备  注：无
*******************************************************************************/
uint8_t IIC_WriteMultByteToSlave(uint8_t IIC_BUS,uint8_t I2C_Addr, uint8_t reg, uint8_t length, uint8_t* data)
{

    if(IIC_BUS == IIC_BUS1)
    {
        uint8_t count = 0;
        IIC1_Start();
        IIC_SendByte(IIC_BUS1,I2C_Addr<<1|0); //发送从机地址
        if(IIC1_WaitAck())
        {
            IIC1_Stop();
            return 1; //从机地址写入失败
        }
        IIC_SendByte(IIC_BUS1,reg); //发送寄存器地址
        IIC1_WaitAck();
        for(count=0; count<length; count++)
        {
            IIC_SendByte(IIC_BUS1,data[count]);
            if(IIC1_WaitAck()) //每一个字节都要等从机应答
            {
                IIC1_Stop();
                return 1; //数据写入失败
            }
        }
        IIC1_Stop(); //产生一个停止条件
        return 0;
    }
    else if(IIC_BUS == IIC_BUS2)
    {
        uint8_t count = 0;
        IIC2_Start();
        IIC_SendByte(IIC_BUS2,I2C_Addr<<1|0); //发送从机地址
        if(IIC2_WaitAck())
        {
            IIC2_Stop();
            return 1; //从机地址写入失败
        }
        IIC_SendByte(IIC_BUS2,reg); //发送寄存器地址
        IIC2_WaitAck();
        for(count=0; count<length; count++)
        {
            IIC_SendByte(IIC_BUS2,data[count]);
            if(IIC2_WaitAck()) //每一个字节都要等从机应答
            {
                IIC2_Stop();
                return 1; //数据写入失败
            }
        }
        IIC2_Stop(); //产生一个停止条件
        return 0;
    }
    else if(IIC_BUS == IIC_BUS3)
    {
        uint8_t count = 0;
        IIC3_Start();
        IIC_SendByte(IIC_BUS3,I2C_Addr<<1|0); //发送从机地址
        if(IIC3_WaitAck())
        {
            IIC3_Stop();
            return 1; //从机地址写入失败
        }
        IIC_SendByte(IIC_BUS3,reg); //发送寄存器地址
        IIC3_WaitAck();
        for(count=0; count<length; count++)
        {
            IIC_SendByte(IIC_BUS3,data[count]);
            if(IIC3_WaitAck()) //每一个字节都要等从机应答
            {
                IIC3_Stop();
                return 1; //数据写入失败
            }
        }
        IIC3_Stop(); //产生一个停止条件
        return 0;
    }
    else if(IIC_BUS == IIC_BUS4)
    {
        uint8_t count = 0;
        IIC4_Start();
        IIC_SendByte(IIC_BUS4,I2C_Addr<<1|0); //发送从机地址
        if(IIC4_WaitAck())
        {
            IIC4_Stop();
            return 1; //从机地址写入失败
        }
        IIC_SendByte(IIC_BUS4,reg); //发送寄存器地址
        IIC4_WaitAck();
        for(count=0; count<length; count++)
        {
            IIC_SendByte(IIC_BUS4,data[count]);
            if(IIC4_WaitAck()) //每一个字节都要等从机应答
            {
                IIC4_Stop();
                return 1; //数据写入失败
            }
        }
        IIC4_Stop(); //产生一个停止条件
        return 0;
    }
    return 0xff;
}
/******************************************************************************
*函  数：uint8_t IIC_WriteAndRead(uint8_t addr,uint8_t *tdata, uint8_t tlen, uint8_t *rdata, uint8_t rlen)
*功　能：IIC先写多个字节后读多个字节
*参  数：addr设备地址
		 *tdata发送数据指针
		 tlen发送数据长度
		 *rdata接收数据指针
		 rlen接收数据长度
*返回值：1成功
*备  注：无
*******************************************************************************/
uint8_t IIC_WriteAndRead(uint8_t IIC_BUS,uint8_t addr,uint8_t *tdata, uint8_t tlen, uint8_t *rdata, uint8_t rlen)
{
    if(IIC_BUS == IIC_BUS1)
    {
        uint8_t i;
        IIC1_Start();
        IIC_SendByte(IIC_BUS1,addr);
        IIC1_WaitAck();
        for(i=0; i<tlen; i++)
        {
            IIC_SendByte(IIC_BUS1,tdata[i]);
            IIC1_WaitAck();
        }
        IIC1_Start();
        IIC_SendByte(IIC_BUS1,addr|0x01);
        IIC1_WaitAck();
        for(i=0; i<(rlen-1); i++)
        {
            rdata[i]= IIC_ReadByte(IIC_BUS1,1);
        }
        rdata[rlen-1]= IIC_ReadByte(IIC_BUS1,0);
        IIC1_Stop();
        return 1;
    }
    else if(IIC_BUS == IIC_BUS2)
    {
        uint8_t i;
        IIC2_Start();
        IIC_SendByte(IIC_BUS2,addr);
        IIC2_WaitAck();
        for(i=0; i<tlen; i++)
        {
            IIC_SendByte(IIC_BUS2,tdata[i]);
            IIC2_WaitAck();
        }
        IIC2_Start();
        IIC_SendByte(IIC_BUS2,addr|0x01);
        IIC2_WaitAck();
        for(i=0; i<(rlen-1); i++)
        {
            rdata[i]= IIC_ReadByte(IIC_BUS2,1);
        }
        rdata[rlen-1]= IIC_ReadByte(IIC_BUS2,0);
        IIC2_Stop();
        return 1;
    }
    else if(IIC_BUS == IIC_BUS3)
    {
        uint8_t i;
        IIC3_Start();
        IIC_SendByte(IIC_BUS3,addr);
        IIC3_WaitAck();
        for(i=0; i<tlen; i++)
        {
            IIC_SendByte(IIC_BUS3,tdata[i]);
            IIC3_WaitAck();
        }
        IIC3_Start();
        IIC_SendByte(IIC_BUS3,addr|0x01);
        IIC3_WaitAck();
        for(i=0; i<(rlen-1); i++)
        {
            rdata[i]= IIC_ReadByte(IIC_BUS3,1);
        }
        rdata[rlen-1]= IIC_ReadByte(IIC_BUS3,0);
        IIC3_Stop();
        return 1;
    }
    else if(IIC_BUS == IIC_BUS4)
    {
        uint8_t i;
        IIC4_Start();
        IIC_SendByte(IIC_BUS4,addr);
        IIC4_WaitAck();
        for(i=0; i<tlen; i++)
        {
            IIC_SendByte(IIC_BUS4,tdata[i]);
            IIC4_WaitAck();
        }
        IIC4_Start();
        IIC_SendByte(IIC_BUS4,addr|0x01);
        IIC4_WaitAck();
        for(i=0; i<(rlen-1); i++)
        {
            rdata[i]= IIC_ReadByte(IIC_BUS4,1);
        }
        rdata[rlen-1]= IIC_ReadByte(IIC_BUS4,0);
        IIC4_Stop();
        return 1;
    }
    return 0xff;
}

